package com.hc.comm.utils;

import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * 字符串工具类
 *
 * @author Ready 2012-10-17
 */
public class StringUtil {

    /**
     * 将对象转化为字符串，如果对象为null，则返回null
     *
     * @param obj
     * @return
     */
    public static String convertObjToString(Object obj) {
        return obj == null ? null : obj.toString();
    }

    /**
     * 如果字符串为空，则返回空字符""
     *
     * @param str
     * @return
     */
    public static String stringNullToEmpty(String str) {
        return str == null ? "" : str;
    }

    /**
     * 如果字符串为空，则返回null
     *
     * @param str
     * @return
     */
    public static String stringEmptyToNull(String str) {
        if (str == null)
            return null;
        return "".equals(str.trim()) ? null : str.trim();
    }

    public static String getPre(int count, String c) {
        StringBuilder result = new StringBuilder("");
        for (int i = 0; i < count; i++) {
            result.append(c);
        }
        return result.toString();
    }

    public static String disponseStr(String str) {
        if (str != null) {
            return str.trim();
        }
        return str;
    }

    /**
     * 是否为空，如果为null或者""，返回false，不为空返回true
     *
     * @param target
     * @return
     */
    public static boolean isNotEmpty(String target) {
        if (target == null || "".equals(target.trim())) {
            return false;
        }
        return true;
    }

    /**
     * 判断字符串是否为空，如果为空返回true
     *
     * @param target
     * @return
     */
    public static boolean isEmpty(String target) {
        return !isNotEmpty(target);
    }

    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            System.out.println(getPre(3 - (i + "").length(), "0") + i);
        }
    }

    /**
     * 替换字符串中的变量。变量的标识符为${}。 例如，模板中${name}变量将会被Map列表中键名为name的键值替换，如果Map列表中不存在所需要
     * 的键名，则会被替换成空。
     *
     * @param template 模板
     * @param data     参数列表
     * @return
     * @throws Exception
     * @author Brian
     */
    public static String fillStringByArgs(String str, Map<Object, Object> data) {
        if (isEmpty(str) || data == null) {
            return str;
        }
        String regex = "\\$\\{(.+?)\\}";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);

		/*
         * sb用来存储替换过的内容，它会把多次处理过的字符串按源字符串序 存储起来。
		 */
        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            String name = matcher.group(1);// 键名
            String value = null == data.get(name) ? "" : data.get(name)
                    .toString();// 键值
            if (value == null) {
                value = "";
            } else {
                value = value.replaceAll("\\$", "\\\\\\$");
            }

            matcher.appendReplacement(sb, value);
        }

        matcher.appendTail(sb);
        return sb.toString();
    }

    public static String cutString(String string, int maxLen, String cutReplace) {
        if (isEmpty(string)) {
            return string;
        } else {
            int len = string.length();
            if (len > maxLen) {
                if (isNotEmpty(cutReplace)) {
                    return string.substring(0, maxLen - cutReplace.length())
                            + cutReplace;
                } else {
                    return string.substring(0, maxLen);
                }
            } else {
                return string;
            }
        }
    }

    /**
     * 将list通过concatstr链接起来
     *
     * @param list
     * @param concatStr
     * @return
     */
    public static String concat(List list, String concatStr) {
        if (list != null) {
            StringBuilder s = new StringBuilder();
            int i = 0;
            for (Object object : list) {
                s.append(convertObjToString(object)).append(
                        (i++ < list.size() - 1) ? concatStr : "");
            }
            return s.toString();
        }
        return null;

    }

    /**
     * @param @param  orgStr
     * @param @param  replaceChar
     * @param @return 设定文件
     * @return String 返回类型
     * @throws
     * @Title: replaceChar
     * @Description: 字符串替换, 将orgStr中的每个字符都替换成replaceChar
     */
    public static String replaceChar(String orgStr, String replaceChar) {
        if (StringUtil.isEmpty(orgStr) || StringUtil.isEmpty(replaceChar)) {
            return orgStr;
        }
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i < orgStr.length(); i++) {
            buffer.append(replaceChar);
        }
        return buffer.toString();
    }

    public static String validStringLenth(String str, int len) {
        if (str == null || str.length() == 0) {
            return "";
        }

        if (str.length() < len) {
            return str;
        }

        return str.substring(0, len);

    }

    public static boolean isNumeric(String str) {
        Pattern pattern = Pattern.compile("[0-9]*");
        return pattern.matcher(str).matches();
    }

    public static boolean isPhone(String str) {
        if (isEmpty(str)) {
            return false;
        }

        return isNumeric(str) && str.length() == 11;
    }

    /**
     * 判斷是否是數字并进行判空
     *
     * @param str
     * @return
     */
    public static boolean isNum(String str) {
        if (isNotEmpty(str)) {
            return isNumeric(str);
        }
        return false;
    }

    /**
     * 随机输出length长度的字符串
     *
     * @param length
     * @return
     */
    public static String getStringRandom(int length) {

        String val = "";
        Random random = new Random();

        //参数length，表示生成几位随机数
        for (int i = 0; i < length; i++) {

            String charOrNum = random.nextInt(2) % 2 == 0 ? "char" : "num";
            //输出字母还是数字
            if ("char".equalsIgnoreCase(charOrNum)) {
                //输出是大写字母还是小写字母
                int temp = random.nextInt(2) % 2 == 0 ? 65 : 97;
                val += (char) (random.nextInt(26) + temp);
            } else if ("num".equalsIgnoreCase(charOrNum)) {
                val += String.valueOf(random.nextInt(10));
            }
        }
        return val;
    }
}
